home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / binutils / arlex.c < prev    next >
C/C++ Source or Header  |  1994-10-13  |  40KB  |  1,551 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. #define FLEX_SCANNER
  4.  
  5. #include <stdio.h>
  6.  
  7.  
  8. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  9. #ifdef c_plusplus
  10. #ifndef __cplusplus
  11. #define __cplusplus
  12. #endif
  13. #endif
  14.  
  15.  
  16. #ifdef __cplusplus
  17.  
  18. #include <stdlib.h>
  19. #include <unistd.h>
  20.  
  21. /* Use prototypes in function declarations. */
  22. #define YY_USE_PROTOS
  23.  
  24. /* The "const" storage-class-modifier is valid. */
  25. #define YY_USE_CONST
  26.  
  27. #else    /* ! __cplusplus */
  28.  
  29. #ifdef __STDC__
  30.  
  31. #define YY_USE_PROTOS
  32. #define YY_USE_CONST
  33.  
  34. #endif    /* __STDC__ */
  35. #endif    /* ! __cplusplus */
  36.  
  37.  
  38. #ifdef __TURBOC__
  39. #define YY_USE_CONST
  40. #endif
  41.  
  42.  
  43. #ifndef YY_USE_CONST
  44. #ifndef const
  45. #define const
  46. #endif
  47. #endif
  48.  
  49.  
  50. #ifdef YY_USE_PROTOS
  51. #define YY_PROTO(proto) proto
  52. #else
  53. #define YY_PROTO(proto) ()
  54. #endif
  55.  
  56. /* Returned upon end-of-file. */
  57. #define YY_NULL 0
  58.  
  59. /* Promotes a possibly negative, possibly signed char to an unsigned
  60.  * integer for use as an array index.  If the signed char is negative,
  61.  * we want to instead treat it as an 8-bit unsigned char, hence the
  62.  * double cast.
  63.  */
  64. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  65.  
  66. /* Enter a start condition.  This macro really ought to take a parameter,
  67.  * but we do it the disgusting crufty way forced on us by the ()-less
  68.  * definition of BEGIN.
  69.  */
  70. #define BEGIN yy_start = 1 + 2 *
  71.  
  72. /* Translate the current start state into a value that can be later handed
  73.  * to BEGIN to return to the state.
  74.  */
  75. #define YY_START ((yy_start - 1) / 2)
  76.  
  77. /* Action number for EOF rule of a given start state. */
  78. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  79.  
  80. /* Special action meaning "start processing a new file".  Now included
  81.  * only for backward compatibility with previous versions of flex.
  82.  */
  83. #define YY_NEW_FILE yyrestart( yyin )
  84.  
  85. #define YY_END_OF_BUFFER_CHAR 0
  86.  
  87. /* Size of default input buffer. */
  88. #define YY_BUF_SIZE 16384
  89.  
  90. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  91.  
  92. extern int yyleng;
  93. extern FILE *yyin, *yyout;
  94.  
  95. #ifdef __cplusplus
  96. extern "C" {
  97. #endif
  98.     extern int yywrap YY_PROTO(( void ));
  99. #ifdef __cplusplus
  100.     }
  101. #endif
  102.  
  103. #define EOB_ACT_CONTINUE_SCAN 0
  104. #define EOB_ACT_END_OF_FILE 1
  105. #define EOB_ACT_LAST_MATCH 2
  106.  
  107. /* The funky do-while in the following #define is used to turn the definition
  108.  * int a single C statement (which needs a semi-colon terminator).  This
  109.  * avoids problems with code like:
  110.  *
  111.  *     if ( condition_holds )
  112.  *        yyless( 5 );
  113.  *    else
  114.  *        do_something_else();
  115.  *
  116.  * Prior to using the do-while the compiler would get upset at the
  117.  * "else" because it interpreted the "if" statement as being all
  118.  * done when it reached the ';' after the yyless() call.
  119.  */
  120.  
  121. /* Return all but the first 'n' matched characters back to the input stream. */
  122.  
  123. #define yyless(n) \
  124.     do \
  125.         { \
  126.         /* Undo effects of setting up yytext. */ \
  127.         *yy_cp = yy_hold_char; \
  128.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  129.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  130.         } \
  131.     while ( 0 )
  132.  
  133. #define unput(c) yyunput( c, yytext_ptr )
  134.  
  135.  
  136. struct yy_buffer_state
  137.     {
  138.     FILE *yy_input_file;
  139.  
  140.     char *yy_ch_buf;        /* input buffer */
  141.     char *yy_buf_pos;        /* current position in input buffer */
  142.  
  143.     /* Size of input buffer in bytes, not including room for EOB
  144.      * characters.
  145.      */
  146.     int yy_buf_size;
  147.  
  148.     /* Number of characters read into yy_ch_buf, not including EOB
  149.      * characters.
  150.      */
  151.     int yy_n_chars;
  152.  
  153.     /* Whether this is an "interactive" input source; if so, and
  154.      * if we're using stdio for input, then we want to use getc()
  155.      * instead of fread(), to make sure we stop fetching input after
  156.      * each newline.
  157.      */
  158.     int yy_is_interactive;
  159.  
  160.     /* Whether to try to fill the input buffer when we reach the
  161.      * end of it.
  162.      */
  163.     int yy_fill_buffer;
  164.  
  165.     /* Whether we've seen an EOF on this buffer. */
  166.     int yy_eof_status;
  167. #define EOF_NOT_SEEN 0
  168.     /* "Pending" happens when the EOF has been seen but there's still
  169.      * some text to process.  Note that when we actually see the EOF,
  170.      * we switch the status back to "not seen" (via yyrestart()), so
  171.      * that the user can continue scanning by just pointing yyin at
  172.      * a new input file.
  173.      */
  174. #define EOF_PENDING 1
  175.     };
  176.  
  177. static YY_BUFFER_STATE yy_current_buffer = 0;
  178.  
  179. /* We provide macros for accessing buffer states in case in the
  180.  * future we want to put the buffer states in a more general
  181.  * "scanner state".
  182.  */
  183. #define YY_CURRENT_BUFFER yy_current_buffer
  184.  
  185.  
  186. /* yy_hold_char holds the character lost when yytext is formed. */
  187. static char yy_hold_char;
  188.  
  189. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  190.  
  191.  
  192. int yyleng;
  193.  
  194. /* Points to current character in buffer. */
  195. static char *yy_c_buf_p = (char *) 0;
  196. static int yy_init = 1;        /* whether we need to initialize */
  197. static int yy_start = 0;    /* start state number */
  198.  
  199. /* Flag which is used to allow yywrap()'s to do buffer switches
  200.  * instead of setting up a fresh yyin.  A bit of a hack ...
  201.  */
  202. static int yy_did_buffer_switch_on_eof;
  203.  
  204. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  205. void yyrestart YY_PROTO(( FILE *input_file ));
  206. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  207. void yy_load_buffer_state YY_PROTO(( void ));
  208. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  209. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  210. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  211.  
  212. static int yy_start_stack_ptr = 0;
  213. static int yy_start_stack_depth = 0;
  214. static int *yy_start_stack = 0;
  215. static void yy_push_state YY_PROTO(( int new_state ));
  216. static void yy_pop_state YY_PROTO(( void ));
  217. static int yy_top_state YY_PROTO(( void ));
  218.  
  219. #ifndef yytext_ptr
  220. static void yy_flex_strcpy YY_PROTO(( char *, const char * ));
  221. #endif
  222.  
  223. static void *yy_flex_alloc YY_PROTO(( unsigned int ));
  224. static void *yy_flex_realloc YY_PROTO(( void *ptr, unsigned int ));
  225. static void yy_flex_free YY_PROTO(( void * ));
  226.  
  227. #define yy_new_buffer yy_create_buffer
  228.  
  229. #define INITIAL 0
  230. typedef unsigned char YY_CHAR;
  231. typedef int yy_state_type;
  232. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  233. extern char *yytext;
  234. #define yytext_ptr yytext
  235.  
  236. #ifdef __cplusplus
  237. static int yyinput YY_PROTO(( void ));
  238. #else
  239. static int input YY_PROTO(( void ));
  240. #endif
  241.  
  242. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  243. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  244. static int yy_get_next_buffer YY_PROTO(( void ));
  245. static void yy_fatal_error YY_PROTO(( const char msg[] ));
  246.  
  247. /* Done after the current pattern has been matched and before the
  248.  * corresponding action - sets up yytext.
  249.  */
  250. #define YY_DO_BEFORE_ACTION \
  251.     yytext_ptr = yy_bp; \
  252.     yyleng = yy_cp - yy_bp; \
  253.     yy_hold_char = *yy_cp; \
  254.     *yy_cp = '\0'; \
  255.     yy_c_buf_p = yy_cp;
  256.  
  257. #define YY_END_OF_BUFFER 41
  258. static const short int yy_accept[177] =
  259.     {   0,
  260.         0,    0,   41,   40,   39,   38,   35,   32,   33,   36,
  261.        40,   34,   37,   35,   35,   35,   35,   35,   35,   35,
  262.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  263.        35,   35,   35,   35,   35,   35,   36,   31,   37,   35,
  264.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  265.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  266.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  267.        35,   35,    7,   35,   35,   35,   35,   35,   35,   35,
  268.        35,   35,   35,   35,   35,   35,   22,   35,   35,   35,
  269.        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
  270.  
  271.        35,   35,   35,   10,   11,   12,   35,   15,   35,   35,
  272.        35,   35,   35,   35,   35,   35,   35,   25,   26,   27,
  273.        35,   30,   35,   35,   35,    3,   35,   35,   35,   35,
  274.        35,   35,   35,   35,   35,   18,   35,   35,   35,   35,
  275.        35,   35,   35,    1,    2,    4,    5,   35,   35,   35,
  276.        35,   35,   16,   17,   19,   20,   35,   35,   35,   35,
  277.        35,   35,    8,    9,   13,   14,   35,   23,   24,   28,
  278.        29,   35,   35,    6,   21,    0
  279.     } ;
  280.  
  281. static const int yy_ec[256] =
  282.     {   0,
  283.         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
  284.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  285.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  286.         1,    3,    1,    1,    1,    4,    1,    1,    1,    5,
  287.         6,    7,    8,    9,    4,    4,    4,    4,    4,    4,
  288.         4,    4,    4,    4,    4,    4,    4,    4,   10,    1,
  289.         1,    1,    1,    1,   11,   12,   13,   14,   15,   16,
  290.         4,   17,   18,    4,    4,   19,   20,   21,   22,   23,
  291.         4,   24,   25,   26,   27,   28,    4,   29,   30,    4,
  292.         1,    1,    1,    1,    4,    1,   31,   32,   33,   34,
  293.  
  294.        35,   36,    4,   37,   38,    4,    4,   39,   40,   41,
  295.        42,   43,    4,   44,   45,   46,   47,   48,    4,   49,
  296.        50,    4,    1,    1,    1,    1,    1,    1,    1,    1,
  297.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  298.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  299.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  300.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  301.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  302.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  303.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  304.  
  305.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  306.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  307.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  308.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  309.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  310.         1,    1,    1,    1,    1
  311.     } ;
  312.  
  313. static const int yy_meta[51] =
  314.     {   0,
  315.         1,    2,    1,    3,    1,    1,    1,    1,    1,    1,
  316.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  317.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  318.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  319.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3
  320.     } ;
  321.  
  322. static const short int yy_base[180] =
  323.     {   0,
  324.         0,    0,  193,  194,  194,  194,    0,  194,  194,    0,
  325.       190,  194,    0,  177,   32,   37,   32,  163,  174,  170,
  326.       164,  171,  174,  169,  149,   15,   22,   17,  135,  146,
  327.       142,  136,  143,  146,  141,    0,    0,  194,    0,  161,
  328.       159,  158,  153,  147,  156,  143,  149,  148,  141,  150,
  329.       141,  135,  138,  127,  125,  124,  119,  113,  122,  109,
  330.       115,  114,  107,  116,  107,  101,  104,   43,  136,  135,
  331.       130,  129,    0,  119,  123,  118,  114,  118,  119,  122,
  332.       124,   25,  104,  103,   98,   97,    0,   87,   91,   86,
  333.        82,   86,   87,   90,   92,  105,  100,   97,   94,   93,
  334.  
  335.       105,  106,  102,    0,    0,    0,  104,    0,   92,   75,
  336.        70,   67,   64,   63,   75,   76,   72,    0,    0,    0,
  337.        74,    0,   62,   91,   88,    0,   86,   85,   73,   85,
  338.        79,   83,   70,   62,   59,    0,   57,   56,   44,   56,
  339.        50,   54,   41,    0,    0,    0,    0,   63,   58,   59,
  340.        67,   66,    0,    0,    0,    0,   38,   33,   34,   42,
  341.        41,   51,    0,    0,    0,    0,   30,    0,    0,    0,
  342.         0,   43,   21,    0,    0,  194,   65,   66,   69
  343.     } ;
  344.  
  345. static const short int yy_def[180] =
  346.     {   0,
  347.       176,    1,  176,  176,  176,  176,  177,  176,  176,  178,
  348.       176,  176,  179,  177,  177,  177,  177,  177,  177,  177,
  349.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  350.       177,  177,  177,  177,  177,  177,  178,  176,  179,  177,
  351.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  352.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  353.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  354.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  355.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  356.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  357.  
  358.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  359.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  360.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  361.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  362.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  363.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  364.       177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
  365.       177,  177,  177,  177,  177,    0,  176,  176,  176
  366.     } ;
  367.  
  368. static const short int yy_nxt[245] =
  369.     {   0,
  370.         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  371.        14,    7,   15,   16,   17,   18,   19,    7,   20,    7,
  372.         7,   21,    7,   22,   23,    7,    7,   24,    7,    7,
  373.        25,    7,   26,   27,   28,   29,   30,    7,   31,    7,
  374.         7,   32,    7,   33,   34,    7,    7,   35,    7,    7,
  375.        41,   43,   45,   55,   44,   42,   57,   59,   56,   58,
  376.        46,   96,   97,  110,  111,   60,   37,   36,   37,   39,
  377.       175,   39,  174,  173,  172,  171,  170,  169,  168,  167,
  378.       166,  165,  164,  163,  162,  161,  160,  159,  158,  157,
  379.       156,  155,  154,  153,  152,  151,  150,  149,  148,  147,
  380.  
  381.       146,  145,  144,  143,  142,  141,  140,  139,  138,  137,
  382.       136,  135,  134,  133,  132,  131,  130,  129,  128,  127,
  383.       126,  125,  124,  123,  122,  121,  120,  119,  118,  117,
  384.       116,  115,  114,  113,  112,  109,  108,  107,  106,  105,
  385.       104,  103,  102,  101,  100,   99,   98,   95,   94,   93,
  386.        92,   91,   90,   89,   88,   87,   86,   85,   84,   83,
  387.        82,   81,   80,   79,   78,   77,   76,   75,   74,   73,
  388.        72,   71,   70,   69,   68,   67,   66,   65,   64,   63,
  389.        62,   61,   54,   53,   52,   51,   50,   49,   48,   47,
  390.        40,   38,  176,    3,  176,  176,  176,  176,  176,  176,
  391.  
  392.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  393.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  394.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  395.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  396.       176,  176,  176,  176
  397.     } ;
  398.  
  399. static const short int yy_chk[245] =
  400.     {   0,
  401.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  402.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  403.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  404.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  405.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  406.        15,   16,   17,   26,   16,   15,   27,   28,   26,   27,
  407.        17,   68,   68,   82,   82,   28,  178,  177,  178,  179,
  408.       173,  179,  172,  167,  162,  161,  160,  159,  158,  157,
  409.       152,  151,  150,  149,  148,  143,  142,  141,  140,  139,
  410.       138,  137,  135,  134,  133,  132,  131,  130,  129,  128,
  411.  
  412.       127,  125,  124,  123,  121,  117,  116,  115,  114,  113,
  413.       112,  111,  110,  109,  107,  103,  102,  101,  100,   99,
  414.        98,   97,   96,   95,   94,   93,   92,   91,   90,   89,
  415.        88,   86,   85,   84,   83,   81,   80,   79,   78,   77,
  416.        76,   75,   74,   72,   71,   70,   69,   67,   66,   65,
  417.        64,   63,   62,   61,   60,   59,   58,   57,   56,   55,
  418.        54,   53,   52,   51,   50,   49,   48,   47,   46,   45,
  419.        44,   43,   42,   41,   40,   35,   34,   33,   32,   31,
  420.        30,   29,   25,   24,   23,   22,   21,   20,   19,   18,
  421.        14,   11,    3,  176,  176,  176,  176,  176,  176,  176,
  422.  
  423.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  424.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  425.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  426.       176,  176,  176,  176,  176,  176,  176,  176,  176,  176,
  427.       176,  176,  176,  176
  428.     } ;
  429.  
  430. static yy_state_type yy_last_accepting_state;
  431. static char *yy_last_accepting_cpos;
  432.  
  433. /* The intent behind this definition is that it'll catch
  434.  * any uses of REJECT which flex missed.
  435.  */
  436. #define REJECT reject_used_but_not_detected
  437. #define yymore() yymore_used_but_not_detected
  438. #define YY_MORE_ADJ 0
  439. char *yytext;
  440. # line 1 "./arlex.l"
  441. # line 2 "./arlex.l"
  442. /* arlex.l - Strange script language lexer */
  443.  
  444. /*   Copyright (C) 1992 Free Software Foundation, Inc.
  445.  
  446. This file is part of GNU Binutils.
  447.  
  448. This program is free software; you can redistribute it and/or modify
  449. it under the terms of the GNU General Public License as published by
  450. the Free Software Foundation; either version 2 of the License, or
  451. (at your option) any later version.
  452.  
  453. This program is distributed in the hope that it will be useful,
  454. but WITHOUT ANY WARRANTY; without even the implied warranty of
  455. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  456. GNU General Public License for more details.
  457.  
  458. You should have received a copy of the GNU General Public License
  459. along with this program; if not, write to the Free Software
  460. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  461.  
  462.  
  463. /* Contributed by Steve Chamberlain
  464.              sac@cygnus.com
  465.  
  466. */
  467. #define DONTDECLARE_MALLOC
  468. #include <ansidecl.h>
  469. #include "arparse.h"
  470. extern char *strdup();
  471. int linenumber;
  472.  
  473. /* Macros after this point can all be overridden by user definitions in
  474.  * section 1.
  475.  */
  476.  
  477. #ifdef YY_MALLOC_DECL
  478. YY_MALLOC_DECL
  479. #else
  480. #if __STDC__
  481. #ifndef __cplusplus
  482. #include <stdlib.h>
  483. #endif
  484. #else
  485. /* Just try to get by without declaring the routines.  This will fail
  486.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  487.  * or sizeof(void*) != sizeof(int).
  488.  */
  489. #endif
  490. #endif
  491.  
  492. /* Amount of stuff to slurp up with each read. */
  493. #ifndef YY_READ_BUF_SIZE
  494. #define YY_READ_BUF_SIZE 8192
  495. #endif
  496.  
  497. /* Copy whatever the last rule matched to the standard output. */
  498.  
  499. #ifndef ECHO
  500. /* This used to be an fputs(), but since the string might contain NUL's,
  501.  * we now use fwrite().
  502.  */
  503. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  504. #endif
  505.  
  506. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  507.  * is returned in "result".
  508.  */
  509. #ifndef YY_INPUT
  510. #define YY_INPUT(buf,result,max_size) \
  511.     if ( yy_current_buffer->yy_is_interactive ) \
  512.         { \
  513.         int c = getc( yyin ); \
  514.         result = c == EOF ? 0 : 1; \
  515.         buf[0] = (char) c; \
  516.         } \
  517.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  518.           && ferror( yyin ) ) \
  519.         YY_FATAL_ERROR( "input in flex scanner failed" );
  520. #endif
  521.  
  522. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  523.  * we don't want an extra ';' after the "return" because that will cause
  524.  * some compilers to complain about unreachable statements.
  525.  */
  526. #ifndef yyterminate
  527. #define yyterminate() return YY_NULL
  528. #endif
  529.  
  530. /* Number of entries by which start-condition stack grows. */
  531. #ifndef YY_START_STACK_INCR
  532. #define YY_START_STACK_INCR 25
  533. #endif
  534.  
  535. /* Report a fatal error. */
  536. #ifndef YY_FATAL_ERROR
  537. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  538. #endif
  539.  
  540. /* Default declaration of generated scanner - a define so the user can
  541.  * easily add parameters.
  542.  */
  543. #ifndef YY_DECL
  544. #define YY_DECL int yylex YY_PROTO(( void ))
  545. #endif
  546.  
  547. /* Code executed at the beginning of each rule, after yytext and yyleng
  548.  * have been set up.
  549.  */
  550. #ifndef YY_USER_ACTION
  551. #define YY_USER_ACTION
  552. #endif
  553.  
  554. /* Code executed at the end of each rule. */
  555. #ifndef YY_BREAK
  556. #define YY_BREAK break;
  557. #endif
  558.  
  559. YY_DECL
  560.     {
  561.     register yy_state_type yy_current_state;
  562.     register char *yy_cp, *yy_bp;
  563.     register int yy_act;
  564.  
  565. # line 33 "./arlex.l"
  566.  
  567.  
  568.  
  569.     if ( yy_init )
  570.         {
  571. #ifdef YY_USER_INIT
  572.         YY_USER_INIT;
  573. #endif
  574.  
  575.         if ( ! yy_start )
  576.             yy_start = 1;    /* first start state */
  577.  
  578.         if ( ! yyin )
  579.             yyin = stdin;
  580.  
  581.         if ( ! yyout )
  582.             yyout = stdout;
  583.  
  584.         if ( yy_current_buffer )
  585.             yy_init_buffer( yy_current_buffer, yyin );
  586.         else
  587.             yy_current_buffer =
  588.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  589.  
  590.         yy_load_buffer_state();
  591.  
  592.         yy_init = 0;
  593.         }
  594.  
  595.     while ( 1 )        /* loops until end-of-file is reached */
  596.         {
  597.         yy_cp = yy_c_buf_p;
  598.  
  599.         /* Support of yytext. */
  600.         *yy_cp = yy_hold_char;
  601.  
  602.         /* yy_bp points to the position in yy_ch_buf of the start of
  603.          * the current run.
  604.          */
  605.         yy_bp = yy_cp;
  606.  
  607.         yy_current_state = yy_start;
  608. yy_match:
  609.         do
  610.             {
  611.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  612.             if ( yy_accept[yy_current_state] )
  613.                 {
  614.                 yy_last_accepting_state = yy_current_state;
  615.                 yy_last_accepting_cpos = yy_cp;
  616.                 }
  617.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  618.                 {
  619.                 yy_current_state = (int) yy_def[yy_current_state];
  620.                 if ( yy_current_state >= 177 )
  621.                     yy_c = yy_meta[(unsigned int) yy_c];
  622.                 }
  623.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  624.             ++yy_cp;
  625.             }
  626.         while ( yy_base[yy_current_state] != 194 );
  627.  
  628. yy_find_action:
  629.         yy_act = yy_accept[yy_current_state];
  630.  
  631.         YY_DO_BEFORE_ACTION;
  632.  
  633.  
  634. do_action:    /* This label is used only to access EOF actions. */
  635.  
  636.  
  637.         switch ( yy_act )
  638.     { /* beginning of action switch */
  639.             case 0: /* must back up */
  640.             /* undo the effects of YY_DO_BEFORE_ACTION */
  641.             *yy_cp = yy_hold_char;
  642.             yy_cp = yy_last_accepting_cpos;
  643.             yy_current_state = yy_last_accepting_state;
  644.             goto yy_find_action;
  645.  
  646. case 1:
  647. YY_USER_ACTION
  648. # line 35 "./arlex.l"
  649. { return ADDLIB; }
  650.     YY_BREAK
  651. case 2:
  652. YY_USER_ACTION
  653. # line 36 "./arlex.l"
  654. { return ADDMOD; }
  655.     YY_BREAK
  656. case 3:
  657. YY_USER_ACTION
  658. # line 37 "./arlex.l"
  659. { return CLEAR; }
  660.     YY_BREAK
  661. case 4:
  662. YY_USER_ACTION
  663. # line 38 "./arlex.l"
  664. { return CREATE; }
  665.     YY_BREAK
  666. case 5:
  667. YY_USER_ACTION
  668. # line 39 "./arlex.l"
  669. { return DELETE; }
  670.     YY_BREAK
  671. case 6:
  672. YY_USER_ACTION
  673. # line 40 "./arlex.l"
  674. { return DIRECTORY; }
  675.     YY_BREAK
  676. case 7:
  677. YY_USER_ACTION
  678. # line 41 "./arlex.l"
  679. { return END; }
  680.     YY_BREAK
  681. case 8:
  682. YY_USER_ACTION
  683. # line 42 "./arlex.l"
  684. { return EXTRACT; }
  685.     YY_BREAK
  686. case 9:
  687. YY_USER_ACTION
  688. # line 43 "./arlex.l"
  689. { return FULLDIR; }
  690.     YY_BREAK
  691. case 10:
  692. YY_USER_ACTION
  693. # line 44 "./arlex.l"
  694. { return HELP; }
  695.     YY_BREAK
  696. case 11:
  697. YY_USER_ACTION
  698. # line 45 "./arlex.l"
  699. { return LIST; }
  700.     YY_BREAK
  701. case 12:
  702. YY_USER_ACTION
  703. # line 46 "./arlex.l"
  704. { return OPEN; }
  705.     YY_BREAK
  706. case 13:
  707. YY_USER_ACTION
  708. # line 47 "./arlex.l"
  709. { return REPLACE; }
  710.     YY_BREAK
  711. case 14:
  712. YY_USER_ACTION
  713. # line 48 "./arlex.l"
  714. { return VERBOSE; }
  715.     YY_BREAK
  716. case 15:
  717. YY_USER_ACTION
  718. # line 49 "./arlex.l"
  719. { return SAVE; }
  720.     YY_BREAK
  721. case 16:
  722. YY_USER_ACTION
  723. # line 50 "./arlex.l"
  724. { return ADDLIB; }
  725.     YY_BREAK
  726. case 17:
  727. YY_USER_ACTION
  728. # line 51 "./arlex.l"
  729. { return ADDMOD; }
  730.     YY_BREAK
  731. case 18:
  732. YY_USER_ACTION
  733. # line 52 "./arlex.l"
  734. { return CLEAR; }
  735.     YY_BREAK
  736. case 19:
  737. YY_USER_ACTION
  738. # line 53 "./arlex.l"
  739. { return CREATE; }
  740.     YY_BREAK
  741. case 20:
  742. YY_USER_ACTION
  743. # line 54 "./arlex.l"
  744. { return DELETE; }
  745.     YY_BREAK
  746. case 21:
  747. YY_USER_ACTION
  748. # line 55 "./arlex.l"
  749. { return DIRECTORY; }
  750.     YY_BREAK
  751. case 22:
  752. YY_USER_ACTION
  753. # line 56 "./arlex.l"
  754. { return END; }
  755.     YY_BREAK
  756. case 23:
  757. YY_USER_ACTION
  758. # line 57 "./arlex.l"
  759. { return EXTRACT; }
  760.     YY_BREAK
  761. case 24:
  762. YY_USER_ACTION
  763. # line 58 "./arlex.l"
  764. { return FULLDIR; }
  765.     YY_BREAK
  766. case 25:
  767. YY_USER_ACTION
  768. # line 59 "./arlex.l"
  769. { return HELP; }
  770.     YY_BREAK
  771. case 26:
  772. YY_USER_ACTION
  773. # line 60 "./arlex.l"
  774. { return LIST; }
  775.     YY_BREAK
  776. case 27:
  777. YY_USER_ACTION
  778. # line 61 "./arlex.l"
  779. { return OPEN; }
  780.     YY_BREAK
  781. case 28:
  782. YY_USER_ACTION
  783. # line 62 "./arlex.l"
  784. { return REPLACE; }
  785.     YY_BREAK
  786. case 29:
  787. YY_USER_ACTION
  788. # line 63 "./arlex.l"
  789. { return VERBOSE; }
  790.     YY_BREAK
  791. case 30:
  792. YY_USER_ACTION
  793. # line 64 "./arlex.l"
  794. { return SAVE; }
  795.     YY_BREAK
  796. case 31:
  797. YY_USER_ACTION
  798. # line 65 "./arlex.l"
  799. { linenumber ++; }
  800.     YY_BREAK
  801. case 32:
  802. YY_USER_ACTION
  803. # line 66 "./arlex.l"
  804. { return '('; }
  805.     YY_BREAK
  806. case 33:
  807. YY_USER_ACTION
  808. # line 67 "./arlex.l"
  809. { return ')'; }
  810.     YY_BREAK
  811. case 34:
  812. YY_USER_ACTION
  813. # line 68 "./arlex.l"
  814. { return ','; }
  815.     YY_BREAK
  816. case 35:
  817. YY_USER_ACTION
  818. # line 69 "./arlex.l"
  819. {     
  820.         yylval.name =  strdup(yytext);
  821.         return FILENAME;
  822.         }
  823.     YY_BREAK
  824. case 36:
  825. YY_USER_ACTION
  826. # line 73 "./arlex.l"
  827. { }
  828.     YY_BREAK
  829. case 37:
  830. YY_USER_ACTION
  831. # line 74 "./arlex.l"
  832. { }
  833.     YY_BREAK
  834. case 38:
  835. YY_USER_ACTION
  836. # line 75 "./arlex.l"
  837. { }
  838.     YY_BREAK
  839. case 39:
  840. YY_USER_ACTION
  841. # line 76 "./arlex.l"
  842. { linenumber ++; return NEWLINE; }    
  843.     YY_BREAK
  844. case 40:
  845. YY_USER_ACTION
  846. # line 78 "./arlex.l"
  847. ECHO;
  848.     YY_BREAK
  849. case YY_STATE_EOF(INITIAL):
  850.     yyterminate();
  851.  
  852.     case YY_END_OF_BUFFER:
  853.         {
  854.         /* Amount of text matched not including the EOB char. */
  855.         int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
  856.  
  857.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  858.         *yy_cp = yy_hold_char;
  859.  
  860.         if ( yy_current_buffer->yy_input_file != yyin )
  861.             {
  862.             /* This can happen if we scan a file, yywrap() returns
  863.              * 1, and then later the user points yyin at a new
  864.              * file to resume scanning.  We have to assure
  865.              * consistency between yy_current_buffer and our
  866.              * globals.  Here is the right place to do so, because
  867.              * this is the first action (other than possibly a
  868.              * back-up) that will match for the new input file.
  869.              */
  870.             yy_current_buffer->yy_input_file = yyin;
  871.             yy_n_chars = yy_current_buffer->yy_n_chars;
  872.             }
  873.  
  874.         /* Note that here we test for yy_c_buf_p "<=" to the position
  875.          * of the first EOB in the buffer, since yy_c_buf_p will
  876.          * already have been incremented past the NUL character
  877.          * (since all states make transitions on EOB to the
  878.          * end-of-buffer state).  Contrast this with the test
  879.          * in input().
  880.          */
  881.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  882.             { /* This was really a NUL. */
  883.             yy_state_type yy_next_state;
  884.  
  885.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  886.  
  887.             yy_current_state = yy_get_previous_state();
  888.  
  889.             /* Okay, we're now positioned to make the NUL
  890.              * transition.  We couldn't have
  891.              * yy_get_previous_state() go ahead and do it
  892.              * for us because it doesn't know how to deal
  893.              * with the possibility of jamming (and we don't
  894.              * want to build jamming into it because then it
  895.              * will run more slowly).
  896.              */
  897.  
  898.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  899.  
  900.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  901.  
  902.             if ( yy_next_state )
  903.                 {
  904.                 /* Consume the NUL. */
  905.                 yy_cp = ++yy_c_buf_p;
  906.                 yy_current_state = yy_next_state;
  907.                 goto yy_match;
  908.                 }
  909.  
  910.             else
  911.                 {
  912.                 goto yy_find_action;
  913.                 }
  914.             }
  915.  
  916.         else switch ( yy_get_next_buffer() )
  917.             {
  918.             case EOB_ACT_END_OF_FILE:
  919.                 {
  920.                 yy_did_buffer_switch_on_eof = 0;
  921.  
  922.                 if ( yywrap() )
  923.                     {
  924.                     /* Note: because we've taken care in
  925.                      * yy_get_next_buffer() to have set up
  926.                      * yytext, we can now set up
  927.                      * yy_c_buf_p so that if some total
  928.                      * hoser (like flex itself) wants to
  929.                      * call the scanner after we return the
  930.                      * YY_NULL, it'll still work - another
  931.                      * YY_NULL will get returned.
  932.                      */
  933.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  934.  
  935.                     yy_act = YY_STATE_EOF(YY_START);
  936.                     goto do_action;
  937.                     }
  938.  
  939.                 else
  940.                     {
  941.                     if ( ! yy_did_buffer_switch_on_eof )
  942.                         YY_NEW_FILE;
  943.                     }
  944.                 break;
  945.                 }
  946.  
  947.             case EOB_ACT_CONTINUE_SCAN:
  948.                 yy_c_buf_p =
  949.                     yytext_ptr + yy_amount_of_matched_text;
  950.  
  951.                 yy_current_state = yy_get_previous_state();
  952.  
  953.                 yy_cp = yy_c_buf_p;
  954.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  955.                 goto yy_match;
  956.  
  957.             case EOB_ACT_LAST_MATCH:
  958.                 yy_c_buf_p =
  959.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  960.  
  961.                 yy_current_state = yy_get_previous_state();
  962.  
  963.                 yy_cp = yy_c_buf_p;
  964.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  965.                 goto yy_find_action;
  966.             }
  967.         break;
  968.         }
  969.  
  970.     default:
  971.         YY_FATAL_ERROR(
  972.             "fatal flex scanner internal error--no action found" );
  973.     } /* end of action switch */
  974.         } /* end of scanning one token */
  975.     } /* end of yylex */
  976.  
  977.  
  978. /* yy_get_next_buffer - try to read in a new buffer
  979.  *
  980.  * Returns a code representing an action:
  981.  *    EOB_ACT_LAST_MATCH -
  982.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  983.  *    EOB_ACT_END_OF_FILE - end of file
  984.  */
  985.  
  986. static int yy_get_next_buffer()
  987.     {
  988.     register char *dest = yy_current_buffer->yy_ch_buf;
  989.     register char *source = yytext_ptr - 1; /* copy prev. char, too */
  990.     register int number_to_move, i;
  991.     int ret_val;
  992.  
  993.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  994.         YY_FATAL_ERROR(
  995.         "fatal flex scanner internal error--end of buffer missed" );
  996.  
  997.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  998.         { /* Don't try to fill the buffer, so this is an EOF. */
  999.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1000.             {
  1001.             /* We matched a singled characater, the EOB, so
  1002.              * treat this as a final EOF.
  1003.              */
  1004.             return EOB_ACT_END_OF_FILE;
  1005.             }
  1006.  
  1007.         else
  1008.             {
  1009.             /* We matched some text prior to the EOB, first
  1010.              * process it.
  1011.              */
  1012.             return EOB_ACT_LAST_MATCH;
  1013.             }
  1014.         }
  1015.  
  1016.     /* Try to read more data. */
  1017.  
  1018.     /* First move last chars to start of buffer. */
  1019.     number_to_move = yy_c_buf_p - yytext_ptr;
  1020.  
  1021.     for ( i = 0; i < number_to_move; ++i )
  1022.         *(dest++) = *(source++);
  1023.  
  1024.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  1025.         /* don't do the read, it's not guaranteed to return an EOF,
  1026.          * just force an EOF
  1027.          */
  1028.         yy_n_chars = 0;
  1029.  
  1030.     else
  1031.         {
  1032.         int num_to_read =
  1033.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1034.  
  1035.         while ( num_to_read <= 0 )
  1036.             { /* Not enough room in the buffer - grow it. */
  1037. #ifdef YY_USES_REJECT
  1038.             YY_FATAL_ERROR(
  1039. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1040. #else
  1041.  
  1042.             /* just a shorter name for the current buffer */
  1043.             YY_BUFFER_STATE b = yy_current_buffer;
  1044.  
  1045.             int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
  1046.  
  1047.             b->yy_buf_size *= 2;
  1048.             b->yy_ch_buf = (char *)
  1049.                 yy_flex_realloc( (void *) b->yy_ch_buf,
  1050.                          b->yy_buf_size );
  1051.  
  1052.             if ( ! b->yy_ch_buf )
  1053.                 YY_FATAL_ERROR(
  1054.                 "fatal error - scanner input buffer overflow" );
  1055.  
  1056.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1057.  
  1058.             num_to_read = yy_current_buffer->yy_buf_size -
  1059.                         number_to_move - 1;
  1060. #endif
  1061.             }
  1062.  
  1063.         if ( num_to_read > YY_READ_BUF_SIZE )
  1064.             num_to_read = YY_READ_BUF_SIZE;
  1065.  
  1066.         /* Read in more data. */
  1067.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1068.             yy_n_chars, num_to_read );
  1069.         }
  1070.  
  1071.     if ( yy_n_chars == 0 )
  1072.         {
  1073.         if ( number_to_move - YY_MORE_ADJ == 1 )
  1074.             {
  1075.             ret_val = EOB_ACT_END_OF_FILE;
  1076.             yyrestart( yyin );
  1077.             }
  1078.  
  1079.         else
  1080.             {
  1081.             ret_val = EOB_ACT_LAST_MATCH;
  1082.             yy_current_buffer->yy_eof_status = EOF_PENDING;
  1083.             }
  1084.         }
  1085.  
  1086.     else
  1087.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1088.  
  1089.     yy_n_chars += number_to_move;
  1090.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1091.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1092.  
  1093.     /* yytext begins at the second character in yy_ch_buf; the first
  1094.      * character is the one which preceded it before reading in the latest
  1095.      * buffer; it needs to be kept around in case it's a newline, so
  1096.      * yy_get_previous_state() will have with '^' rules active.
  1097.      */
  1098.  
  1099.     yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
  1100.  
  1101.     return ret_val;
  1102.     }
  1103.  
  1104.  
  1105. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1106.  
  1107. static yy_state_type yy_get_previous_state()
  1108.     {
  1109.     register yy_state_type yy_current_state;
  1110.     register char *yy_cp;
  1111.  
  1112.     yy_current_state = yy_start;
  1113.  
  1114.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1115.         {
  1116.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1117.         if ( yy_accept[yy_current_state] )
  1118.             {
  1119.             yy_last_accepting_state = yy_current_state;
  1120.             yy_last_accepting_cpos = yy_cp;
  1121.             }
  1122.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1123.             {
  1124.             yy_current_state = (int) yy_def[yy_current_state];
  1125.             if ( yy_current_state >= 177 )
  1126.                 yy_c = yy_meta[(unsigned int) yy_c];
  1127.             }
  1128.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1129.         }
  1130.  
  1131.     return yy_current_state;
  1132.     }
  1133.  
  1134.  
  1135. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1136.  *
  1137.  * synopsis
  1138.  *    next_state = yy_try_NUL_trans( current_state );
  1139.  */
  1140.  
  1141. #ifdef YY_USE_PROTOS
  1142. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1143. #else
  1144. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1145. yy_state_type yy_current_state;
  1146. #endif
  1147.     {
  1148.     register int yy_is_jam;
  1149.     register char *yy_cp = yy_c_buf_p;
  1150.  
  1151.     register YY_CHAR yy_c = 1;
  1152.     if ( yy_accept[yy_current_state] )
  1153.         {
  1154.         yy_last_accepting_state = yy_current_state;
  1155.         yy_last_accepting_cpos = yy_cp;
  1156.         }
  1157.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1158.         {
  1159.         yy_current_state = (int) yy_def[yy_current_state];
  1160.         if ( yy_current_state >= 177 )
  1161.             yy_c = yy_meta[(unsigned int) yy_c];
  1162.         }
  1163.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1164.     yy_is_jam = (yy_current_state == 176);
  1165.  
  1166.     return yy_is_jam ? 0 : yy_current_state;
  1167.     }
  1168.  
  1169.  
  1170. #ifdef YY_USE_PROTOS
  1171. static void yyunput( int c, register char *yy_bp )
  1172. #else
  1173. static void yyunput( c, yy_bp )
  1174. int c;
  1175. register char *yy_bp;
  1176. #endif
  1177.     {
  1178.     register char *yy_cp = yy_c_buf_p;
  1179.  
  1180.     /* undo effects of setting up yytext */
  1181.     *yy_cp = yy_hold_char;
  1182.  
  1183.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1184.         { /* need to shift things up to make room */
  1185.         /* +2 for EOB chars. */
  1186.         register int number_to_move = yy_n_chars + 2;
  1187.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1188.                     yy_current_buffer->yy_buf_size + 2];
  1189.         register char *source =
  1190.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1191.  
  1192.         while ( source > yy_current_buffer->yy_ch_buf )
  1193.             *--dest = *--source;
  1194.  
  1195.         yy_cp += dest - source;
  1196.         yy_bp += dest - source;
  1197.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1198.  
  1199.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1200.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1201.         }
  1202.  
  1203.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  1204.         yy_cp[-2] = '\n';
  1205.  
  1206.     *--yy_cp = (char) c;
  1207.  
  1208.  
  1209.     /* Note: the formal parameter *must* be called "yy_bp" for this
  1210.      * macro to now work correctly.
  1211.      */
  1212.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1213.     }
  1214.  
  1215.  
  1216. #ifdef __cplusplus
  1217. static int yyinput()
  1218. #else
  1219. static int input()
  1220. #endif
  1221.     {
  1222.     int c;
  1223.  
  1224.     *yy_c_buf_p = yy_hold_char;
  1225.  
  1226.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1227.         {
  1228.         /* yy_c_buf_p now points to the character we want to return.
  1229.          * If this occurs *before* the EOB characters, then it's a
  1230.          * valid NUL; if not, then we've hit the end of the buffer.
  1231.          */
  1232.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1233.             /* This was really a NUL. */
  1234.             *yy_c_buf_p = '\0';
  1235.  
  1236.         else
  1237.             { /* need more input */
  1238.             yytext_ptr = yy_c_buf_p;
  1239.             ++yy_c_buf_p;
  1240.  
  1241.             switch ( yy_get_next_buffer() )
  1242.                 {
  1243.                 case EOB_ACT_END_OF_FILE:
  1244.                     {
  1245.                     if ( yywrap() )
  1246.                         {
  1247.                         yy_c_buf_p =
  1248.                         yytext_ptr + YY_MORE_ADJ;
  1249.                         return EOF;
  1250.                         }
  1251.  
  1252.                     YY_NEW_FILE;
  1253. #ifdef __cplusplus
  1254.                     return yyinput();
  1255. #else
  1256.                     return input();
  1257. #endif
  1258.                     }
  1259.  
  1260.                 case EOB_ACT_CONTINUE_SCAN:
  1261.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1262.                     break;
  1263.  
  1264.                 case EOB_ACT_LAST_MATCH:
  1265. #ifdef __cplusplus
  1266.                     YY_FATAL_ERROR(
  1267.                     "unexpected last match in yyinput()" );
  1268. #else
  1269.                     YY_FATAL_ERROR(
  1270.                     "unexpected last match in input()" );
  1271. #endif
  1272.                 }
  1273.             }
  1274.         }
  1275.  
  1276.     c = *yy_c_buf_p;
  1277.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1278.     yy_hold_char = *++yy_c_buf_p;
  1279.  
  1280.     return c;
  1281.     }
  1282.  
  1283.  
  1284. #ifdef YY_USE_PROTOS
  1285. void yyrestart( FILE *input_file )
  1286. #else
  1287. void yyrestart( input_file )
  1288. FILE *input_file;
  1289. #endif
  1290.     {
  1291.     if ( ! yy_current_buffer )
  1292.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1293.  
  1294.     yy_init_buffer( yy_current_buffer, input_file );
  1295.     yy_load_buffer_state();
  1296.     }
  1297.  
  1298.  
  1299. #ifdef YY_USE_PROTOS
  1300. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1301. #else
  1302. void yy_switch_to_buffer( new_buffer )
  1303. YY_BUFFER_STATE new_buffer;
  1304. #endif
  1305.     {
  1306.     if ( yy_current_buffer == new_buffer )
  1307.         return;
  1308.  
  1309.     if ( yy_current_buffer )
  1310.         {
  1311.         /* Flush out information for old buffer. */
  1312.         *yy_c_buf_p = yy_hold_char;
  1313.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1314.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1315.         }
  1316.  
  1317.     yy_current_buffer = new_buffer;
  1318.     yy_load_buffer_state();
  1319.  
  1320.     /* We don't actually know whether we did this switch during
  1321.      * EOF (yywrap()) processing, but the only time this flag
  1322.      * is looked at is after yywrap() is called, so it's safe
  1323.      * to go ahead and always set it.
  1324.      */
  1325.     yy_did_buffer_switch_on_eof = 1;
  1326.     }
  1327.  
  1328.  
  1329. #ifdef YY_USE_PROTOS
  1330. void yy_load_buffer_state( void )
  1331. #else
  1332. void yy_load_buffer_state()
  1333. #endif
  1334.     {
  1335.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1336.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1337.     yyin = yy_current_buffer->yy_input_file;
  1338.     yy_hold_char = *yy_c_buf_p;
  1339.     }
  1340.  
  1341.  
  1342. #ifdef YY_USE_PROTOS
  1343. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1344. #else
  1345. YY_BUFFER_STATE yy_create_buffer( file, size )
  1346. FILE *file;
  1347. int size;
  1348. #endif
  1349.     {
  1350.     YY_BUFFER_STATE b;
  1351.  
  1352.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1353.  
  1354.     if ( ! b )
  1355.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1356.  
  1357.     b->yy_buf_size = size;
  1358.  
  1359.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1360.      * we need to put in 2 end-of-buffer characters.
  1361.      */
  1362.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1363.  
  1364.     if ( ! b->yy_ch_buf )
  1365.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1366.  
  1367.     yy_init_buffer( b, file );
  1368.  
  1369.     return b;
  1370.     }
  1371.  
  1372.  
  1373. #ifdef YY_USE_PROTOS
  1374. void yy_delete_buffer( YY_BUFFER_STATE b )
  1375. #else
  1376. void yy_delete_buffer( b )
  1377. YY_BUFFER_STATE b;
  1378. #endif
  1379.     {
  1380.     if ( b == yy_current_buffer )
  1381.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1382.  
  1383.     yy_flex_free( (void *) b->yy_ch_buf );
  1384.     yy_flex_free( (void *) b );
  1385.     }
  1386.  
  1387.  
  1388. #ifdef YY_USE_PROTOS
  1389. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1390. #else
  1391. void yy_init_buffer( b, file )
  1392. YY_BUFFER_STATE b;
  1393. FILE *file;
  1394. #endif
  1395.     {
  1396.     b->yy_input_file = file;
  1397.  
  1398.     /* We put in the '\n' and start reading from [1] so that an
  1399.      * initial match-at-newline will be true.
  1400.      */
  1401.  
  1402.     b->yy_ch_buf[0] = '\n';
  1403.     b->yy_n_chars = 1;
  1404.  
  1405.     /* We always need two end-of-buffer characters.  The first causes
  1406.      * a transition to the end-of-buffer state.  The second causes
  1407.      * a jam in that state.
  1408.      */
  1409.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1410.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1411.  
  1412.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1413.  
  1414.     b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
  1415.  
  1416.     b->yy_fill_buffer = 1;
  1417.  
  1418.     b->yy_eof_status = EOF_NOT_SEEN;
  1419.     }
  1420.  
  1421.  
  1422. #ifdef YY_USE_PROTOS
  1423. static void yy_push_state( int new_state )
  1424. #else
  1425. static void yy_push_state( new_state )
  1426. int new_state;
  1427. #endif
  1428.     {
  1429.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1430.         {
  1431.         int new_size;
  1432.  
  1433.         yy_start_stack_depth += YY_START_STACK_INCR;
  1434.         new_size = yy_start_stack_depth * sizeof( int );
  1435.  
  1436.         if ( ! yy_start_stack )
  1437.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1438.  
  1439.         else
  1440.             yy_start_stack = (int *) yy_flex_realloc(
  1441.                     (void *) yy_start_stack, new_size );
  1442.  
  1443.         if ( ! yy_start_stack )
  1444.             YY_FATAL_ERROR(
  1445.             "out of memory expanding start-condition stack" );
  1446.         }
  1447.  
  1448.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1449.  
  1450.     BEGIN(new_state);
  1451.     }
  1452.  
  1453.  
  1454. static void yy_pop_state()
  1455.     {
  1456.     if ( --yy_start_stack_ptr < 0 )
  1457.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1458.  
  1459.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1460.     }
  1461.  
  1462.  
  1463. static int yy_top_state()
  1464.     {
  1465.     return yy_start_stack[yy_start_stack_ptr - 1];
  1466.     }
  1467.  
  1468.  
  1469. #ifdef YY_USE_PROTOS
  1470. static void yy_fatal_error( const char msg[] )
  1471. #else
  1472. static void yy_fatal_error( msg )
  1473. char msg[];
  1474. #endif
  1475.     {
  1476.     (void) fprintf( stderr, "%s\n", msg );
  1477.     exit( 1 );
  1478.     }
  1479.  
  1480.  
  1481.  
  1482. /* Redefine yyless() so it works in section 3 code. */
  1483.  
  1484. #undef yyless
  1485. #define yyless(n) \
  1486.     do \
  1487.         { \
  1488.         /* Undo effects of setting up yytext. */ \
  1489.         yytext[yyleng] = yy_hold_char; \
  1490.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1491.         yy_hold_char = *yy_c_buf_p; \
  1492.         *yy_c_buf_p = '\0'; \
  1493.         yyleng = n; \
  1494.         } \
  1495.     while ( 0 )
  1496.  
  1497.  
  1498. /* Internal utility routines. */
  1499.  
  1500. #ifndef yytext_ptr
  1501. #ifdef YY_USE_PROTOS
  1502. static void yy_flex_strcpy( char *s1, const char *s2 )
  1503. #else
  1504. static void yy_flex_strcpy( s1, s2 )
  1505. char *s1;
  1506. const char *s2;
  1507. #endif
  1508.     {
  1509.     while ( (*(s1++) = *(s2++)) )
  1510.         ;
  1511.     }
  1512. #endif
  1513.  
  1514.  
  1515. #ifdef YY_USE_PROTOS
  1516. static void *yy_flex_alloc( unsigned int size )
  1517. #else
  1518. static void *yy_flex_alloc( size )
  1519. unsigned int size;
  1520. #endif
  1521.     {
  1522.     return (void *) malloc( size );
  1523.     }
  1524.  
  1525. #ifdef YY_USE_PROTOS
  1526. static void *yy_flex_realloc( void *ptr, unsigned int size )
  1527. #else
  1528. static void *yy_flex_realloc( ptr, size )
  1529. void *ptr;
  1530. unsigned int size;
  1531. #endif
  1532.     {
  1533.     return (void *) realloc( ptr, size );
  1534.     }
  1535.  
  1536. #ifdef YY_USE_PROTOS
  1537. static void yy_flex_free( void *ptr )
  1538. #else
  1539. static void yy_flex_free( ptr )
  1540. void *ptr;
  1541. #endif
  1542.     {
  1543.     free( ptr );
  1544.     }
  1545. # line 78 "./arlex.l"
  1546.  
  1547. #ifndef yywrap
  1548. /* Needed for lex, though not flex. */
  1549. int yywrap() { return 1; }
  1550. #endif
  1551.